
public class Slides {

//    Slides for Java
    
    // EASY SHORT
    static String j1 = "1.1 - A Java Program\n" +
    			"- In the Java programming language\n" +
    			"- a program is made up of one or more classes\n" +
    			"- a class contains one or more methods\n" +
    			"- a method contains program statements\n" +
    			"- These terms will be explored in detail throughout the course\n" +
    			"- A Java application always contains a method called main\n\n" +
    			"#---------#      #---------#      #---------#\n" +
    			"# Program # ---> # Classes # ---> # Methods #\n" +
    			"#---------#      #---------#      #---------#\n";
    
    // EASY LONG
    static String j2 = "   _ ____ _  _ ____\n" +
    			"___| |--|  \\/  |--|\n" +
    			"1.1 - Comments\n" +
    			"- Comments in a program are called inline documentation\n" +
    			"- They should be included to explain the purpose of the\n" +
    			"program and describe processing steps\n" +
    			"- They do not affect how a program works\n" +
    			"- Java comments can take three forms\n" +
    			"// this comment runs to the end of the line\n" +
    			"/* this comment runs to the terminating\n" +
    			"symbol, even across line breaks */\n" +
    			"/** this is a javadoc comment */\n";
    
    // MODERATE SHORT
    static String j3 = "1.1 - White Space\n" +
    			"- Spaces, blank lines, and tabs are called white space\n" +
    			"- White space is used to separate words and symbols in a\n" +
    			"program\n" +
    			"- Extra white space is ignored\n" +
    			"- A valid Java program can be formatted many ways\n" +
    			"- Programs should be formatted to enhance readability,\n" +
    			"using consistent indentation\n";
    
    // PRO LONG
    static String j4 = "1.2 - Java Translation\n" +
    			"- The Java compiler translates Java source code into a\n" +
    			"special representation called bytecode\n" +
    			"-- Java bytecode is not the machine language for any\n" +
    			"traditional CPU\n" +
    			"- Another software tool, called an interpreter, translates\n" +
    			"bytecode into machine language and executes it\n" +
    			"- Therefore the Java compiler is not tied to any particular\n" +
    			"machine\n" +
    			"- Java is considered to be architecture-neutral\n";
    
    // MODERATE LONG
    static String j5 = "____ ____ ____ ____ ____ ____ \n" +
    			"|___ |__/ |__/ |  | |__/ [__  \n" +
    			"|___ |  \\ |  \\ |__| |  \\ ___]\n" + 
    			"- A program can have three types of errors\n" +
    			"- The compiler will find syntax errors and other basic problems\n" +
    			"(compile-time errors)\n" +
    			"- If compile-time errors exist, an executable version of the\n" +
    			"program is not created\n" +
    			"- A problem can occur during program execution, such as trying\n" +
    			"to divide by zero, which causes a program to terminate\n" +
    			"abnormally (run-time errors)\n" +
    			"- A program may run, but produce incorrect results, perhaps\n" +
    			"using an incorrect formula (logical errors)\n";
    
    // PRO SHORT
    static String j6 = "1.4 - Software Development Activities\n" +
    			"- Software requirements specify what a program must accomplish\n" +
    			"- Requirements are expressed in a document called a functional\n" +
    			"specification\n" +
    			"- A software design indicates how a program will accomplish its\n" +
    			"requirements\n" +
    			"- Implementation is the process of writing the source code that will\n" +
    			"solve the problem\n" +
    			"- Testing is the act of ensuring that a program will solve the intended\n" +
    			"problem given all of the constraints under which it must perform\n";
    
//  Slides for the first presentation in C++

// Easy + Short
    static String s1=  "\nYou can derive a class from any number of base "
                + "classes.\nDeriving a class from more than one direct base"
                + " class is called multiple inheritance.\n"
                + "In the following example, classes A, B, and C are direct\n"
                + "base classes for the derived class X: \n"
                + "\nclass A { /* ... */ };\n"
                + "class B { /* ... */ };\n"
                + "class C { /* ... */ };\n"
                + "class X : public A, private B, public C { /* ... */ };\n"
                + "\nThe following inheritance graph describes the inheritance \n"
                + "relationships of the above example. An arrow points to the \n"
                + "direct base class of the class at the tail of the arrow:\n"
                + "   ______    ______     ______\n"
                + "  |__A___|  |__B___|   |__C___| \n"
                + "     |         |          |\n"
                + "     |_________|__________|\n"
                + "            ___|__\n"
                + "           |__X___| \n  ";


//Easy+Long

      static String s2="\nMultiple inheritance enables a derived class to inherit \n"
                + "members from more than one parent.Let\'s say we wanted to \n"
                + "write a program to keep track of a bunch of teachers. A \n"
                + "teacher is a person. However, a teacher is also an employee \n"
                + "(they are their own employer if working for themselves). \n"
                + "Multiple inheritance can be used to create a Teacher class \n"
                + "that inherits properties from both Person and Employee.\n"
                + "To use multiple inheritance, simply specify each base class \n"
                + "(just like in single inheritance), separated by a comma.\n"
                + "   ___________       _____________\n"
                + "  |__Person___|     |__Employee___| \n"
                + "       |                  |       \n"
                + "       |__________________|\n"
                + "         ______|_____\n"
                + "        |__Teacher___| \n  ";

//      Moderate+Short

    static String s3="\nMultiple inheritance allows a class to take on functionality \n"
                + "from multiple other classes, such as allowing a class named \n"
                + "StreetMusician to inherit from a class named Human, a class \n"
                + "named Musician, and a class named Worker. This can be \n"
                + "abbreviated StreetMusician : Human, Musician, Worker.\n"
                + "Ambiguities arise in multiple inheritance, as in the example\n"
                + " above, if for instance the class Musician inherited from \n"
                + "Human and Worker and the class Worker inherited from Human. \n\n"
                + "#############################################\n"
                + "#Worker         :  Human                    # \n"
                + "#Musician       :  Human, Worker            # \n"
                + "#StreetMusician :  Human, Musician, Worker  #\n"
                + "#############################################\n";

//    Moderate+Long

    static String s4="\nWhile multiple inheritance seems like a simple extension of\n"
                + " single inheritance, multiple inheritance introduces a lot of \n"
                + "issues that can markedly increase the complexity of programs \n"
                + "and make them a maintenance nightmare. Let\'s take a look at \n"
                + "some of these situations.\n\n"
                + "################################################\n"
                + "#class PoweredDevice                           #\n"
                + "#{                                             #\n"
                + "#};                                            #\n"
                + "#class Scanner: public PoweredDevice           #\n"
                + "#{                                             #\n"
                + "#};                                            #\n"
                + "#class Printer: public PoweredDevice           #\n"
                + "#{                                             #\n"
                + "#};                                            #\n"
                + "#class Copier: public Scanner, public Printer  #\n"
                + "#{                                             #\n"
                + "#};                                            #\n"
                + "################################################\n";

//    Pro+Long
    static String s5="\nIf a compiler is looking at the class StreetMusician, it needs\n"
                + "to know whether it should join identical features together, \n"
                + "or whether they should be separate features. For instance, \n"
                + "it would make sense to join the Age features of Human \n"
                + "together for StreetMusician. A human's age doesn't change, if\n"
                + "you consider them a human, a worker, or a musician. It \n"
                + "would, however, make sense to separate the feature Name in \n"
                + "Human and Musician, if they use a different stage name than \n"
                + "their given name. The options of joining and separating are \n"
                + "both valid in their own context and only the programmer \n"
                + "knows which option is correct for the class they are \n"
                + "designing.\n";


//    Pro+Short

    static String s6="\nGenerally, virtual base classes are most suitable when the\n"
                + "classes that derive from the virtual base, and especially \n"
                + "the virtual base itself, are pure abstract classes. This \n"
                + "means the classes above the join class have very little if \n"
                + "any data.\n";

    
    

}
